home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpuzzles.3 / xpuzzles / xpuzzles-5.3.1 / xcubes / xmcubes.c < prev   
C/C++ Source or Header  |  1996-02-07  |  15KB  |  520 lines
  1. /*
  2. # MOTIF-BASED CUBES
  3. #
  4. #  xmcubes.c
  5. #
  6. ###
  7. #
  8. #  Copyright (c) 1993 - 96    David Albert Bagley, bagleyd@hertz.njit.edu
  9. #
  10. #                   All Rights Reserved
  11. #
  12. #  Permission to use, copy, modify, and distribute this software and
  13. #  its documentation for any purpose and without fee is hereby granted,
  14. #  provided that the above copyright notice appear in all copies and
  15. #  that both that copyright notice and this permission notice appear in
  16. #  supporting documentation, and that the name of the author not be
  17. #  used in advertising or publicity pertaining to distribution of the
  18. #  software without specific, written prior permission.
  19. #
  20. #  This program is distributed in the hope that it will be "useful",
  21. #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22. #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  23. #
  24. */
  25.  
  26. /*
  27.   Version 5: 95/10/01 Xt/Motif
  28.   Version 4: 94/06/07 Xt
  29.   Version 3: 93/04/01 Motif
  30.   Version 2: 92/12/19 XView
  31. */
  32.  
  33. #include <stdlib.h>
  34. #include <stdio.h>
  35. #ifdef VMS
  36. #include <unixlib.h>
  37. #define getlogin cuserid
  38. #else
  39. #ifndef apollo
  40. #include <unistd.h>
  41. #endif
  42. #endif
  43. #include <X11/Intrinsic.h>
  44. #include <X11/StringDefs.h>
  45. #include <X11/Shell.h>
  46. #include <X11/cursorfont.h>
  47. #include <Xm/PanedW.h>
  48. #include <Xm/RowColumn.h>
  49. #include <Xm/Label.h>
  50. #include <Xm/LabelG.h>
  51. #include <Xm/Scale.h>
  52. #include "Cubes.h"
  53. #include "cubes.xbm"
  54. #include "mouse-l.xbm"
  55. #include "mouse-r.xbm"
  56.  
  57. #ifndef SCOREFILE
  58. #define SCOREFILE "/usr/games/lib/cubes.scores"
  59. #endif
  60.  
  61. /* The following is in CubesP.h also */
  62. #define MINCUBES 1 
  63.  
  64. #define MAXCUBES 8
  65. #define MAXRECORD 32767
  66.  
  67. static void Initialize();
  68. static void CallbackCubes();
  69.  
  70. static void PrintRecord();
  71. static int HandleSolved();
  72. static void ReadRecords();
  73. static void WriteRecords();
  74.  
  75. static void motif_printf();
  76. static void BlockXSlider();
  77. static void BlockYSlider();
  78. static void BlockZSlider();
  79.  
  80. static Arg arg[2];
  81. static Widget moves, record, message, cubes, blockX, blockY, blockZ;
  82. static int cubesRecord[MAXCUBES - MINCUBES + 1][MAXCUBES - MINCUBES + 1]
  83.   [MAXCUBES - MINCUBES + 1], movesDsp = 0;
  84. static char messageDsp[128] = "Welcome";
  85.  
  86. static void Usage()
  87. {
  88.   (void) fprintf(stderr, "usage: xmcubes\n");
  89.   (void) fprintf(stderr,
  90.     "\t[-geometry [{width}][x{height}][{+-}{xoff}[{+-}{yoff}]]]\n");
  91.   (void) fprintf(stderr,
  92.     "\t[-display [{host}]:[{vs}]][-fg {color}] [-bg {color}]\n");
  93.   (void) fprintf(stderr,
  94.     "\t[-brick {color}] [-{border|bd} {color}] [-size{x|y|z} {int}]\n");
  95.   exit(1);
  96. }
  97.  
  98. static XrmOptionDescRec options[] = {
  99.   {"-fg",        "*cubes.Foreground",    XrmoptionSepArg,    NULL},
  100.   {"-bg",        "*Background",        XrmoptionSepArg,    NULL},
  101.   {"-foreground",    "*cubes.Foreground",    XrmoptionSepArg,    NULL},
  102.   {"-background",    "*Background",        XrmoptionSepArg,    NULL},
  103.   {"-brick",        "*cubes.brickColor",    XrmoptionSepArg,    NULL},
  104.   {"-border",        "*cubes.brickBorder",    XrmoptionSepArg,    NULL},
  105.   {"-bd",        "*cubes.brickBorder",    XrmoptionSepArg,    NULL},
  106.   {"-sizex",        "*cubes.sizeX",        XrmoptionSepArg,    NULL},
  107.   {"-sizey",        "*cubes.sizeY",        XrmoptionSepArg,    NULL},
  108.   {"-sizez",        "*cubes.sizeZ",        XrmoptionSepArg,    NULL},
  109. };
  110.  
  111. int main(argc, argv)
  112.   int argc;
  113.   char *argv[];
  114. {
  115.   Widget toplevel;
  116.   Widget panel, panel2, rowcol, rowcol2;
  117.   Pixmap mouseLeftCursor, mouseRightCursor;
  118.   Pixel fg, bg;
  119.  
  120.   toplevel = XtInitialize(argv[0], "Cubes",
  121.     options, XtNumber(options), &argc, argv);
  122.   if (argc != 1)
  123.     Usage();
  124.  
  125.   XtSetArg(arg[0], XtNiconPixmap,
  126.     XCreateBitmapFromData(XtDisplay(toplevel),
  127.       RootWindowOfScreen(XtScreen(toplevel)),
  128.       (char *) cubes_bits, cubes_width, cubes_height));
  129.   XtSetArg(arg[1], XmNkeyboardFocusPolicy, XmPOINTER); /* not XmEXPLICIT */
  130.   XtSetValues(toplevel, arg, 2);
  131.   panel = XtCreateManagedWidget("panel", xmPanedWindowWidgetClass, toplevel,
  132.     NULL, 0);
  133.   panel2 = XtVaCreateManagedWidget("panel2", xmPanedWindowWidgetClass, panel,
  134.     XmNseparatorOn, False,
  135.     XmNsashWidth, 1,
  136.     XmNsashHeight, 1,
  137.     NULL);
  138.  
  139.   rowcol = XtVaCreateManagedWidget("Rowcol", xmRowColumnWidgetClass, panel2,
  140.     XmNnumColumns, 2,
  141.     XmNorientation, XmHORIZONTAL,
  142.     XmNpacking, XmPACK_COLUMN,
  143.     NULL);
  144.   XtVaGetValues(rowcol, XmNforeground, &fg, XmNbackground, &bg, NULL);
  145.   mouseLeftCursor = XCreatePixmapFromBitmapData(XtDisplay(rowcol),
  146.     RootWindowOfScreen(XtScreen(rowcol)), mouse_left_bits,
  147.     mouse_left_width, mouse_left_height, fg, bg,
  148.     DefaultDepthOfScreen(XtScreen(rowcol)));
  149.   mouseRightCursor = XCreatePixmapFromBitmapData(XtDisplay(rowcol),
  150.     RootWindowOfScreen(XtScreen(rowcol)), mouse_right_bits,
  151.     mouse_right_width, mouse_right_height, fg, bg,
  152.     DefaultDepthOfScreen(XtScreen(rowcol)));
  153.   XtVaCreateManagedWidget("mouseLeftText", xmLabelGadgetClass, rowcol,
  154.     XtVaTypedArg, XmNlabelString, XmRString, "Move brick", 11, NULL);
  155.   XtVaCreateManagedWidget("mouseLeft", xmLabelGadgetClass, rowcol,
  156.     XmNlabelType, XmPIXMAP, XmNlabelPixmap, mouseLeftCursor, NULL);
  157.   XtVaCreateManagedWidget("mouseRightText", xmLabelGadgetClass, rowcol,
  158.     XtVaTypedArg, XmNlabelString, XmRString, "Randomize", 10, NULL);
  159.   XtVaCreateManagedWidget("mouseRight", xmLabelGadgetClass, rowcol,
  160.     XmNlabelType, XmPIXMAP, XmNlabelPixmap, mouseRightCursor, NULL);
  161.   XtVaCreateManagedWidget("movesText", xmLabelGadgetClass, rowcol,
  162.     XtVaTypedArg, XmNlabelString, XmRString, "Moves", 6, NULL);
  163.   moves = XtVaCreateManagedWidget("0", xmLabelWidgetClass, rowcol, NULL);
  164.   XtVaCreateManagedWidget("recordText", xmLabelGadgetClass, rowcol,
  165.     XtVaTypedArg, XmNlabelString, XmRString, "Record", 7, NULL);
  166.   record = XtVaCreateManagedWidget("0", xmLabelWidgetClass, rowcol, NULL);
  167.  
  168.   rowcol2 = XtVaCreateManagedWidget("Rowcol2", xmRowColumnWidgetClass, panel2,
  169.     NULL);
  170.   XtVaGetValues(rowcol2, XmNforeground, &fg, XmNbackground, &bg, NULL);
  171.   blockX = XtVaCreateManagedWidget("blockX", xmScaleWidgetClass, rowcol2,
  172.     XtVaTypedArg, XmNtitleString, XmRString, "Blocks X", 8,
  173.     XmNminimum, MINCUBES,
  174.     XmNmaximum, MAXCUBES,
  175.     XmNvalue, MINCUBES,
  176.     XmNshowValue, True,
  177.     XmNorientation, XmHORIZONTAL,
  178.     NULL);
  179.   XtAddCallback(blockX, XmNvalueChangedCallback, BlockXSlider, NULL);
  180.   blockY = XtVaCreateManagedWidget("blockY", xmScaleWidgetClass, rowcol2,
  181.     XtVaTypedArg, XmNtitleString, XmRString, "Blocks Y", 8,
  182.     XmNminimum, MINCUBES,
  183.     XmNmaximum, MAXCUBES,
  184.     XmNvalue, MINCUBES,
  185.     XmNshowValue, True,
  186.     XmNorientation, XmHORIZONTAL,
  187.     NULL);
  188.   XtAddCallback(blockY, XmNvalueChangedCallback, BlockYSlider, NULL);
  189.   blockZ = XtVaCreateManagedWidget("blockZ", xmScaleWidgetClass, rowcol2,
  190.     XtVaTypedArg, XmNtitleString, XmRString, "Blocks Z", 8,
  191.     XmNminimum, MINCUBES,
  192.     XmNmaximum, MAXCUBES,
  193.     XmNvalue, MINCUBES,
  194.     XmNshowValue, True,
  195.     XmNorientation, XmHORIZONTAL,
  196.     NULL);
  197.   XtAddCallback(blockZ, XmNvalueChangedCallback, BlockZSlider, NULL);
  198.   message = XtVaCreateManagedWidget("Play Cubes! (use mouse or keypad)",
  199.     xmLabelWidgetClass, rowcol2,
  200.     NULL);
  201.  
  202.   cubes = XtCreateManagedWidget("cubes", cubesWidgetClass, panel, NULL,
  203.     0);
  204.   XtAddCallback(cubes, XtNselectCallback, CallbackCubes, NULL);
  205.   Initialize(cubes);
  206.   XtRealizeWidget(toplevel);
  207.   XGrabButton(XtDisplay(cubes), AnyButton, AnyModifier, XtWindow(cubes),
  208.     TRUE, ButtonPressMask | ButtonMotionMask | ButtonReleaseMask,
  209.     GrabModeAsync, GrabModeAsync, XtWindow(cubes),
  210.     XCreateFontCursor(XtDisplay(cubes), XC_crosshair));
  211.   XtMainLoop();
  212.  
  213. #ifdef VMS
  214.   return 1;
  215. #else
  216.   return 0;
  217. #endif
  218. }
  219.  
  220. static void Initialize(w)
  221.   Widget w;
  222. {
  223.   int sizeX, sizeY, sizeZ;
  224.  
  225.   XtVaSetValues(w,
  226.     XtNstart, FALSE,
  227.     NULL);
  228.   XtVaGetValues(w,
  229.     XtNsizeX, &sizeX,
  230.     XtNsizeY, &sizeY,
  231.     XtNsizeZ, &sizeZ,
  232.     NULL);
  233.   if (sizeX <= MAXCUBES)
  234.     XmScaleSetValue(blockX, sizeX);
  235.   if (sizeY <= MAXCUBES)
  236.     XmScaleSetValue(blockY, sizeY);
  237.   if (sizeZ <= MAXCUBES)
  238.     XmScaleSetValue(blockZ, sizeZ);
  239.   ReadRecords();
  240.   PrintRecord(sizeX, sizeY, sizeZ);
  241. }
  242.  
  243. static void CallbackCubes(w, clientData, callData)
  244.   Widget w;
  245.   caddr_t clientData;
  246.   cubesCallbackStruct *callData;
  247. {
  248.   int sizeX, sizeY, sizeZ;
  249.  
  250.   XtVaGetValues(w,
  251.     XtNsizeX, &sizeX,
  252.     XtNsizeY, &sizeY,
  253.     XtNsizeZ, &sizeZ,
  254.     NULL);
  255.   (void) strcpy(messageDsp, "");
  256.   switch (callData->reason) {
  257.     case CUBES_RESTORE:
  258.     case CUBES_RESET:
  259.       movesDsp = 0;
  260.       break;
  261.     case CUBES_BLOCKED:
  262.       (void) strcpy(messageDsp, "Blocked");
  263.       break;
  264.     case CUBES_SPACE:
  265.       /*(void) strcpy(messageDsp, "Spaces can't move");*/  /* Too annoying */
  266.       break;
  267.     case CUBES_IGNORE:
  268.       (void) strcpy(messageDsp, "Randomize to start");
  269.       break;
  270.     case CUBES_MOVED:
  271.       movesDsp++;
  272.       XtSetArg(arg[0], XtNstart, TRUE);
  273.       XtSetValues(w, arg, 1);
  274.       break;
  275.     case CUBES_SOLVED:
  276.       if (HandleSolved(movesDsp, sizeX, sizeY, sizeZ))
  277.         (void) sprintf(messageDsp, "Congratulations %s!!", getlogin());
  278.       else
  279.         (void) strcpy(messageDsp, "Solved!");
  280.       XtSetArg(arg[0], XtNstart, FALSE);
  281.       XtSetValues(w, arg, 1);
  282.       break;
  283.     case CUBES_RANDOMIZE:
  284.       movesDsp = 0;
  285.       XtSetArg(arg[0], XtNstart, FALSE);
  286.       XtSetValues(w, arg, 1);
  287.       break;
  288.     case CUBES_DEC_X:
  289.       movesDsp = 0;
  290.       sizeX--;
  291.       PrintRecord(sizeX, sizeY, sizeZ);
  292.       XtSetArg(arg[0], XtNsizeX, sizeX);
  293.       XtSetValues(w, arg, 1);
  294.       if (sizeX <= MAXCUBES)
  295.         XmScaleSetValue(blockX, sizeX);
  296.       break;
  297.     case CUBES_INC_X:
  298.       movesDsp = 0;
  299.       sizeX++;
  300.       PrintRecord(sizeX, sizeY, sizeZ);
  301.       XtSetArg(arg[0], XtNsizeX, sizeX);
  302.       XtSetValues(w, arg, 1);
  303.       if (sizeX <= MAXCUBES)
  304.         XmScaleSetValue(blockX, sizeX);
  305.       break;
  306.     case CUBES_DEC_Y:
  307.       movesDsp = 0;
  308.       sizeY--;
  309.       PrintRecord(sizeX, sizeY, sizeZ);
  310.       XtSetArg(arg[0], XtNsizeY, sizeY);
  311.       XtSetValues(w, arg, 1);
  312.       if (sizeY <= MAXCUBES)
  313.         XmScaleSetValue(blockY, sizeY);
  314.       break;
  315.     case CUBES_INC_Y:
  316.       movesDsp = 0;
  317.       sizeY++;
  318.       PrintRecord(sizeX, sizeY, sizeZ);
  319.       XtSetArg(arg[0], XtNsizeY, sizeY);
  320.       XtSetValues(w, arg, 1);
  321.       if (sizeY <= MAXCUBES)
  322.         XmScaleSetValue(blockY, sizeY);
  323.       break;
  324.     case CUBES_DEC_Z:
  325.       movesDsp = 0;
  326.       sizeZ--;
  327.       PrintRecord(sizeX, sizeY, sizeZ);
  328.       XtSetArg(arg[0], XtNsizeZ, sizeZ);
  329.       XtSetValues(w, arg, 1);
  330.       if (sizeZ <= MAXCUBES)
  331.         XmScaleSetValue(blockZ, sizeZ);
  332.       break;
  333.     case CUBES_INC_Z:
  334.       movesDsp = 0;
  335.       sizeZ++;
  336.       PrintRecord(sizeX, sizeY, sizeZ);
  337.       XtSetArg(arg[0], XtNsizeZ, sizeZ);
  338.       XtSetValues(w, arg, 1);
  339.       if (sizeZ <= MAXCUBES)
  340.         XmScaleSetValue(blockZ, sizeZ);
  341.       break;
  342.     case CUBES_COMPUTED:
  343.       XtSetArg(arg[0], XtNstart, FALSE);
  344.       XtSetValues(w, arg, 1);
  345.       break;
  346.     case CUBES_UNDO:
  347.       movesDsp--;
  348.       XtSetArg(arg[0], XtNstart, TRUE);
  349.       XtSetValues(w, arg, 1);
  350.       break;
  351.   }
  352.   motif_printf(message, "%s", messageDsp);
  353.   motif_printf(moves, "%d", movesDsp);
  354. }
  355.  
  356. static void BlockXSlider(w, clientData, cbs)
  357.   Widget w;
  358.   XtPointer clientData;
  359.   XmScaleCallbackStruct *cbs;
  360. {
  361.   int sizeX = cbs->value, sizeY, sizeZ, oldX;
  362.  
  363.   XtVaGetValues(cubes,
  364.     XtNsizeX, &oldX,
  365.     XtNsizeY, &sizeY,
  366.     XtNsizeZ, &sizeZ,
  367.     NULL);  
  368.   if (oldX != sizeX) {
  369.     XtVaSetValues(cubes,
  370.       XtNsizeX, sizeX,
  371.       NULL);
  372.     movesDsp = 0;
  373.     motif_printf(moves, "%d", movesDsp);
  374.     PrintRecord(sizeX, sizeY, sizeZ);
  375.   }
  376. }
  377.  
  378. static void BlockYSlider(w, clientData, cbs)
  379.   Widget w;
  380.   XtPointer clientData;
  381.   XmScaleCallbackStruct *cbs;
  382. {
  383.   int sizeX, sizeY = cbs->value, sizeZ, oldY;
  384.  
  385.   XtVaGetValues(cubes,
  386.     XtNsizeX, &sizeX,
  387.     XtNsizeY, &oldY,
  388.     XtNsizeZ, &sizeZ,
  389.     NULL);  
  390.   if (oldY != sizeY) {
  391.     XtVaSetValues(cubes,
  392.       XtNsizeY, sizeY,
  393.       NULL);
  394.     movesDsp = 0;
  395.     motif_printf(moves, "%d", movesDsp);
  396.     PrintRecord(sizeX, sizeY, sizeZ);
  397.   }
  398. }
  399.  
  400. static void BlockZSlider(w, clientData, cbs)
  401.   Widget w;
  402.   XtPointer clientData;
  403.   XmScaleCallbackStruct *cbs;
  404. {
  405.   int sizeX, sizeY, sizeZ = cbs->value, oldZ;
  406.  
  407.   XtVaGetValues(cubes,
  408.     XtNsizeX, &sizeX,
  409.     XtNsizeY, &sizeY,
  410.     XtNsizeZ, &oldZ,
  411.     NULL);  
  412.   if (oldZ != sizeZ) {
  413.     XtVaSetValues(cubes,
  414.       XtNsizeZ, sizeZ,
  415.       NULL);
  416.     movesDsp = 0;
  417.     motif_printf(moves, "%d", movesDsp);
  418.     PrintRecord(sizeX, sizeY, sizeZ);
  419.   }
  420. }
  421.  
  422. static void PrintRecord(sizeX, sizeY, sizeZ)
  423.   int sizeX, sizeY, sizeZ;
  424. {
  425.   int i = sizeX - MINCUBES, j = sizeY - MINCUBES, k = sizeZ - MINCUBES;
  426.  
  427.   if (sizeX > MAXCUBES || sizeY > MAXCUBES || sizeZ > MAXCUBES)
  428.     motif_printf(record, "NOT RECORDED");
  429.   else if (cubesRecord[i][j][k] >= MAXRECORD)
  430.     motif_printf(record, "NEVER");
  431.   else
  432.     motif_printf(record, "%d", cubesRecord[i][j][k]);
  433. }
  434.  
  435. static int HandleSolved(counter, sizeX, sizeY, sizeZ)
  436.   int counter, sizeX, sizeY, sizeZ;
  437. {
  438.   int i = sizeX - MINCUBES, j = sizeY - MINCUBES, k = sizeZ - MINCUBES;
  439.  
  440.   if (sizeX <= MAXCUBES && sizeY <= MAXCUBES && sizeZ <= MAXCUBES &&
  441.       counter < cubesRecord[i][j][k]) {
  442.     cubesRecord[i][j][k] = cubesRecord[i][k][j] = cubesRecord[j][i][k] =
  443.       cubesRecord[j][k][i] = cubesRecord[k][i][j] = cubesRecord[k][j][i] =
  444.       counter;
  445.     WriteRecords();
  446.     PrintRecord(sizeX, sizeY, sizeZ);
  447.     return TRUE;
  448.   }
  449.   return FALSE;
  450. }
  451.  
  452. static void ReadRecords()
  453. {
  454.   FILE *fp;
  455.   int i, j, k, n;
  456.  
  457.   for (i = 0; i < MAXCUBES - MINCUBES + 1; i++)
  458.     for (j = i; j < MAXCUBES - MINCUBES + 1; j++)
  459.       for (k = j; k < MAXCUBES - MINCUBES + 1; k++)
  460.         cubesRecord[k][j][i] = cubesRecord[k][i][j] =
  461.           cubesRecord[j][k][i] = cubesRecord[j][i][k] =
  462.           cubesRecord[i][k][j] = cubesRecord[i][j][k] = MAXRECORD;
  463.   if ((fp = fopen(SCOREFILE, "r")) == NULL)
  464.     motif_printf(message, "Can not open %s, taking defaults.\n", SCOREFILE);
  465.   else {
  466.     for (i = 0; i < MAXCUBES - MINCUBES + 1; i++)
  467.       for (j = i; j < MAXCUBES - MINCUBES + 1; j++)
  468.         for (k = j; k < MAXCUBES - MINCUBES + 1; k++) {
  469.           (void) fscanf(fp, "%d", &n);
  470.           cubesRecord[k][j][i] = cubesRecord[k][i][j] =
  471.             cubesRecord[j][k][i] = cubesRecord[j][i][k] =
  472.             cubesRecord[i][k][j] = cubesRecord[i][j][k] = n;
  473.         }
  474.     (void) fclose(fp);
  475.   }
  476. }
  477.  
  478. static void WriteRecords()
  479. {
  480.   FILE *fp;
  481.   int i, j, k;
  482.  
  483.   if ((fp = fopen(SCOREFILE, "w")) == NULL)
  484.     motif_printf(message, "Can not write to %s.\n", SCOREFILE);
  485.   else {
  486.     for (i = 0; i < MAXCUBES - MINCUBES + 1; i++) {
  487.       for (j = i; j < MAXCUBES - MINCUBES + 1; j++) {
  488.         for (k = j; k < MAXCUBES - MINCUBES + 1; k++)
  489.           (void) fprintf(fp, "%d ", cubesRecord[i][j][k]);
  490.         (void) fprintf(fp, "\n");
  491.       }
  492.       (void) fprintf(fp, "\n");
  493.     }
  494.     (void) fclose(fp);
  495.   }
  496. }
  497.  
  498. #include <varargs.h>
  499. static void motif_printf(va_alist)
  500.   va_dcl
  501. {
  502.   Widget w;
  503.   char *format;
  504.   va_list args;
  505.   char str[1000];
  506.   Arg wargs[10];
  507.   XmString xmstr;
  508.  
  509.   va_start(args);
  510.   w = va_arg(args, Widget);
  511.   if (!XtIsSubclass(w, xmLabelWidgetClass))
  512.     XtError("motif_printf() requires a Label Widget");
  513.   format = va_arg(args, char *);
  514.   (void) vsprintf(str, format, args);
  515.   xmstr = XmStringCreateLtoR(str, XmSTRING_DEFAULT_CHARSET);
  516.   XtSetArg(wargs[0], XmNlabelString, xmstr);
  517.   XtSetValues(w, wargs, 1);
  518.   va_end(args);
  519. }
  520.